﻿using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Graphics;
using StardewModdingAPI;
using StardewModdingAPI.Events;
using StardewValley;
using StardewValley.Menus;

namespace WorseGame.Content
{
    public class 开局负债(IMonitor monitor, IModHelper helper)
    {
        public readonly IMonitor 监视器 = monitor;
        public readonly IModHelper 助手 = helper;
        public const int 初始债务 = 100000000;
        public const int 月还款额 = 10000;
        public const double 利率 = 0.0005;
        public int 当前债务 = 初始债务;
        public int 上次还款季节 = -1;
        public int 上次还款年份 = -1;
        public bool 已初始化 = false;
        public bool 显示债务界面 = true;
        public bool 本月已惩罚 = false;
        public bool 自动还款模式 = true;
        private Rectangle 手动还款按钮区域;
        private Rectangle 自动还款切换按钮区域;
      
        public int 本月固定应还款额 = 0;
        public int 本月已还款额 = 0;

        public void Initialize()
        {
            助手.Events.GameLoop.DayStarted += 每日开始;
            助手.Events.GameLoop.SaveLoaded += 存档加载;
            助手.Events.Display.RenderedHud += 渲染界面;
            助手.Events.Input.ButtonPressed += 按键按下;
        }

        public void 按键按下(object? sender, ButtonPressedEventArgs e)
        {
            if (e.Button == SButton.F7)
            {
                Game1.playSound(显示债务界面 ? "bigSelect" : "bigDeSelect");
                显示债务界面 = !显示债务界面;
            }

            if (显示债务界面 && e.Button == SButton.MouseLeft)
            {
                var 鼠标位置 = 助手.Input.GetCursorPosition().ScreenPixels;
                int 鼠标X = (int)鼠标位置.X;
                int 鼠标Y = (int)鼠标位置.Y;

                if (手动还款按钮区域.Contains(鼠标X, 鼠标Y))
                {
                    手动还款();
                }

                if (自动还款切换按钮区域.Contains(鼠标X, 鼠标Y))
                {
                    自动还款模式 = !自动还款模式;
                    Game1.playSound(自动还款模式 ? "money" : "cancel");

                }
            }
        }

        public void 存档加载(object? sender, SaveLoadedEventArgs e)
        {
            加载债务数据();
            已初始化 = true;
        }

        public void 每日开始(object? sender, DayStartedEventArgs e)
        {
            if (已初始化)
            {
                if (Game1.dayOfMonth == 1)
                {
                    本月已惩罚 = false;

                    if (上次还款季节 != Game1.seasonIndex || 上次还款年份 != Game1.year)
                    {
                        int 利息 = (int)(当前债务 * 利率);
                        本月固定应还款额 = Math.Min(月还款额 + 利息, 当前债务);
                        本月已还款额 = 0;
                    }
                }

                if (Game1.dayOfMonth == 1 && 自动还款模式)
                {
                    自动还款();
                }
            }
        }

        public void 自动还款()
        {
            if (上次还款季节 != Game1.seasonIndex || 上次还款年份 != Game1.year)
            {
                int 利息 = (int)(当前债务 * 利率);
                当前债务 += 利息;
                int 本次还款额 = Math.Min(月还款额, 当前债务);

                if (Game1.player.Money >= 本次还款额)
                {
                    Game1.player.Money -= 本次还款额;
                    当前债务 -= 本次还款额;
                    上次还款季节 = Game1.seasonIndex;
                    上次还款年份 = Game1.year;
                    保存债务数据();
                }
                else
                {
                    施加惩罚();
                    保存债务数据();
                }
            }
        }

        public void 手动还款()
        {
            if (上次还款季节 == Game1.seasonIndex && 上次还款年份 == Game1.year)
            {
                Game1.playSound("cancel");
                return;
            }

            int 玩家金币 = Game1.player.Money;

            int 剩余应还款额 = 本月固定应还款额 - 本月已还款额;
            int 实际还款额 = Math.Min(玩家金币, 剩余应还款额);

            Game1.player.Money -= 实际还款额;
            当前债务 -= 实际还款额;
            本月已还款额 += 实际还款额;

            if (本月已还款额 >= 本月固定应还款额)
            {
                上次还款季节 = Game1.seasonIndex;
                上次还款年份 = Game1.year;
            }

            保存债务数据();

            if (实际还款额 > 0)
            {
                Game1.playSound("purchase");
            }
            else
            {
                Game1.playSound("cancel");
            }
        }

        public void 施加惩罚()
        {
            if (!本月已惩罚)
            {
                float 当前体力 = Game1.player.stamina;
                Game1.player.stamina = Math.Max(1, 当前体力 / 2);
                int 当前生命值 = Game1.player.health;
                Game1.player.health = Math.Max(1, 当前生命值 / 2);
                Game1.playSound("debuffHit");
                本月已惩罚 = true;
            }
        }

        public void 渲染界面(object? sender, RenderedHudEventArgs e)
        {
            if (Context.IsWorldReady && 显示债务界面)
            {
                绘制债务界面(e.SpriteBatch);
            }
        }

        public void 绘制债务界面(SpriteBatch spriteBatch)
        {
            int 界面宽度 = 320;
            int 界面高度 = 320;
            int 界面X = 20;
            int 界面Y = 100;

            IClickableMenu.drawTextureBox(spriteBatch, Game1.menuTexture, new Rectangle(0, 256, 60, 60), 界面X, 界面Y, 界面宽度, 界面高度, Color.White);

            string 标题 = "债务信息";
            Vector2 标题尺寸 = Game1.dialogueFont.MeasureString(标题);
            Vector2 标题位置 = new(界面X + (界面宽度 - 标题尺寸.X) / 2, 界面Y + 16);
            Utility.drawTextWithShadow(spriteBatch, 标题, Game1.dialogueFont, 标题位置, Game1.textColor);

            int 文本Y = 界面Y + 60;
            int 行高 = 30;
            bool 本月已还款 = 上次还款季节 == Game1.seasonIndex && 上次还款年份 == Game1.year;

            int 剩余应还款额 = 本月固定应还款额 - 本月已还款额;

            绘制信息行(spriteBatch, 界面X, 文本Y, 界面宽度, "当前债务：", $"{当前债务:#,0}g", 获取债务颜色(当前债务));
            绘制信息行(spriteBatch, 界面X, 文本Y + 行高, 界面宽度, "本月应还：", $"{本月固定应还款额:#,0}g", 本月已还款 ? Color.LightGreen : Color.White);
            绘制信息行(spriteBatch, 界面X, 文本Y + 行高 * 2, 界面宽度, "已还/剩余：", $"{本月已还款额:#,0}g / {剩余应还款额:#,0}g", Color.White);
            绘制信息行(spriteBatch, 界面X, 文本Y + 行高 * 3, 界面宽度, "利息：", $"{利率 * 100}%", Color.White);
            绘制信息行(spriteBatch, 界面X, 文本Y + 行高 * 4, 界面宽度, "当前金币：", $"{Game1.player.Money:#,0}g", Color.Gold);

            string 还款状态 = 本月已还款 ? "本月已还" : "待还款";
            Color 还款状态颜色 = 本月已还款 ? Color.LightGreen : Color.Orange;
            绘制信息行(spriteBatch, 界面X, 文本Y + 行高 * 5, 界面宽度, "还款状态：", 还款状态, 还款状态颜色);

            string 惩罚状态 = 本月已惩罚 ? "已施加惩罚" : "正常";
            Color 惩罚颜色 = 本月已惩罚 ? Color.Red : Color.LightGreen;
            绘制信息行(spriteBatch, 界面X, 文本Y + 行高 * 6, 界面宽度, "惩罚状态：", 惩罚状态, 惩罚颜色);

            绘制按钮(spriteBatch, 界面X, 界面Y, 界面宽度, 界面高度, 本月已还款);

            string 提示文字 = "按 F7 隐藏";
            Vector2 提示尺寸 = Game1.smallFont.MeasureString(提示文字);
            Utility.drawTextWithShadow(spriteBatch, 提示文字, Game1.smallFont, new Vector2(界面X + 界面宽度 - 提示尺寸.X - 15, 界面Y + 界面高度 + 10), Color.Gray);
        }
        private void 绘制按钮(SpriteBatch spriteBatch, int 界面X, int 界面Y, int 界面宽度, int 界面高度, bool 本月已还款)
        {
            int 按钮Y = 界面Y + 界面高度 - 55;
            int 按钮宽度 = 140;
            int 按钮高度 = 40;
            int 按钮间距 = 10;

            int 手动按钮X = 界面X + 按钮间距;
            手动还款按钮区域 = new Rectangle(手动按钮X, 按钮Y, 按钮宽度, 按钮高度);

            Color 手动按钮颜色;
            if (本月已还款)
            {
                手动按钮颜色 = Color.Gray;
            }
            else
            {
                手动按钮颜色 = 手动还款按钮区域.Contains(Game1.getMouseX(), Game1.getMouseY()) ? Color.Wheat : Color.White;
            }

            IClickableMenu.drawTextureBox(spriteBatch, Game1.menuTexture, new Rectangle(0, 256, 60, 60), 手动按钮X, 按钮Y, 按钮宽度, 按钮高度, 手动按钮颜色);

            string 手动按钮文字 = 本月已还款 ? "已还款" : "手动还款";
            Vector2 手动文字尺寸 = Game1.smallFont.MeasureString(手动按钮文字);
            Vector2 手动文字位置 = new(手动按钮X + (按钮宽度 - 手动文字尺寸.X) / 2, 按钮Y + (按钮高度 - 手动文字尺寸.Y) / 2);
            Color 手动文字颜色 = 本月已还款 ? Color.DarkGray : Color.Black;
            Utility.drawTextWithShadow(spriteBatch, 手动按钮文字, Game1.smallFont, 手动文字位置, 手动文字颜色);
            int 自动按钮X = 界面X + 界面宽度 - 按钮宽度 - 按钮间距;
            自动还款切换按钮区域 = new Rectangle(自动按钮X, 按钮Y, 按钮宽度, 按钮高度);

            Color 自动按钮颜色 = 自动还款切换按钮区域.Contains(Game1.getMouseX(), Game1.getMouseY()) ? Color.Wheat : Color.White;
            IClickableMenu.drawTextureBox(spriteBatch, Game1.menuTexture, new Rectangle(0, 256, 60, 60), 自动按钮X, 按钮Y, 按钮宽度, 按钮高度, 自动按钮颜色);

            string 自动按钮文字 = 自动还款模式 ? "关闭自动" : "开启自动";
            Vector2 自动文字尺寸 = Game1.smallFont.MeasureString(自动按钮文字);
            Vector2 自动文字位置 = new(自动按钮X + (按钮宽度 - 自动文字尺寸.X) / 2, 按钮Y + (按钮高度 - 自动文字尺寸.Y) / 2);
            Utility.drawTextWithShadow(spriteBatch, 自动按钮文字, Game1.smallFont, 自动文字位置, Color.Black);
        }

        public static void 绘制信息行(SpriteBatch spriteBatch, int x, int y, int width, string 标签, string 数值, Color 数值颜色)
        {
            int 内边距 = 20;
            Utility.drawTextWithShadow(spriteBatch, 标签, Game1.smallFont, new Vector2(x + 内边距, y), Game1.textColor);
            Vector2 数值尺寸 = Game1.smallFont.MeasureString(数值);
            Utility.drawTextWithShadow(spriteBatch, 数值, Game1.smallFont, new Vector2(x + width - 数值尺寸.X - 内边距, y), 数值颜色);
        }

        public static Color 获取债务颜色(int 债务)
        {
            return 债务 switch
            {
                > 80000000 => Color.Red,
                > 50000000 => Color.Orange,
                > 20000000 => Color.Yellow,
                _ => Color.LightGreen
            };
        }

        public void 加载债务数据()
        {
            string? 债务数据 = 助手.Data.ReadSaveData<string>("DebtSystemData");
            if (!string.IsNullOrEmpty(债务数据))
            {
                var 数据数组 = 债务数据.Split(',');
                if (数据数组.Length >= 3)
                {
                    当前债务 = int.Parse(数据数组[0]);
                    上次还款季节 = int.Parse(数据数组[1]);
                    上次还款年份 = int.Parse(数据数组[2]);
                }
            }
            else
            {
                当前债务 = 初始债务;
                上次还款季节 = -1;
                上次还款年份 = -1;
            }

            string? 自动还款数据 = 助手.Data.ReadSaveData<string>("AutoRepaymentMode");
            自动还款模式 = 自动还款数据 != "false";

            if (上次还款季节 != Game1.seasonIndex || 上次还款年份 != Game1.year)
            {
                int 利息 = (int)(当前债务 * 利率);
                本月固定应还款额 = Math.Min(月还款额 + 利息, 当前债务);
                本月已还款额 = 0;
            }
            else
            {
                本月固定应还款额 = 0;
                本月已还款额 = 0;
            }
        }

        public void 保存债务数据()
        {
            string 债务数据 = $"{当前债务},{上次还款季节},{上次还款年份}";
            助手.Data.WriteSaveData("DebtSystemData", 债务数据);
            助手.Data.WriteSaveData("AutoRepaymentMode", 自动还款模式.ToString().ToLower());
        }
    }
}